My First Experience with Vibe Coding - Claude Code on Desktop

Last December, while experimenting with Vibe Coding, I chose to use Claude Code on desktop and started by testing it on an old project. During my Vibe Coding practice, I didn't intervene much because I wanted to understand the extent of its capabilities. Furthermore, I only knew about Claude's 5-hour reset quota; I didn't realize there was a hidden Weekly Active Compute Hours limit (Anthropic mentioned in a late August 2025 notification that Pro users have approximately 40-80 hours of Sonnet 4 compute per week). Because Vibe Coding consumes tokens much faster than expected, I not only exhausted my quota early but was also locked out for several days because the weekly quota is calculated on a "7-day rolling" basis. Coupled with my decision to pause my subscription to evaluate GitHub Copilot, this test was never actually completed.

Since I am currently unable to access the system to take screenshots, this article records the experience through text only.

What is Claude Code on Desktop?

In the November 25, 2025 update, Claude Desktop added a Code tab, an interface that allows you to run Claude Code directly within the desktop application. Users do not need to open a terminal; they simply click the tab and install the dependencies to get started.

Operation Mechanism

After using it, I found its isolation logic quite unique. When a repository is selected, it does not modify the original files directly. Instead, it creates a folder with the same name as the project under the .claude-worktrees directory in the user's home folder. It then generates a randomly named subfolder (containing a full copy of the project) and creates a randomly named Git branch inside it.

All modifications occur within this isolated environment and branch. This design ensures the safety of the original project and enables the possibility of handling multiple tasks in parallel (each session corresponds to a different isolated environment).

Actual Experience

The Huge Difference in Context Understanding

In the early days of using AI assistance (like ChatGPT), I was often limited by the input caps of the UI. Although long-text and file uploads were supported later, there is still a massive difference in precision compared to the context gained by Vibe Coding's direct reading of the entire project.

Previously, because I was too lazy to code, I would write the logic and expected steps for Claude and ask it to generate the code for me to adjust. However, I often encountered output length limits that caused the code to be truncated. When I asked it to "continue generating," the subsequent code sometimes wouldn't connect properly (this was especially severe in early ChatGPT). When the logic I needed to write was too extensive, it was easy to spend a lot of time organizing the code because the details from multiple outputs couldn't be stitched together.

In the Vibe Coding mode, the AI can fully understand the project structure, and the generated code no longer suffers from truncation issues. This is the biggest difference in experience compared to traditional conversational AI.

Full of Emotional Value

I have to say, Vibe Coding feels great to use. It's like a senior colleague with a stable temperament who can discuss things with you and help handle more tedious tasks. When I ask it to optimize code, it not only follows instructions obediently but also provides detailed explanations. Sometimes, when I wasted my quota and asked, "Am I asking for too much?", it replied, "This is what good engineering quality is all about." It provides plenty of emotional value.

Issues and Pitfalls Encountered

1. Session Cannot Be Resumed

This is the most serious problem I encountered. When there is no activity for too long, a 401 Unauthorized error appears when entering a message, meaning that once the connection is lost, the old session can never be recovered. Even worse, if you open a new session, it forces the creation of a brand new random isolated environment in .claude-worktrees. This prevents me from continuing my original work progress, resetting all context to zero, which is the most frustrating point for me.

TIP

Regarding this issue, I later discovered an unofficial workaround. See: Solving the issue where Claude Code on desktop cannot resume sessions

2. Logical Contradictions in Context Understanding

I have my own preferences for Commit Messages and Coding Style, so I wrote relevant documentation and asked it to read them, but the process did not go smoothly.

First, after a session disconnects and reconnects, it often forgets previous settings. I once asked if I needed to reference other Markdown files in CLAUDE.md, and it confidently told me, "No need, I will read all Markdown files when loading." But testing showed it didn't read them at all. When I questioned it, it changed its story, saying, "I only read CLAUDE.md when loading, but I read the commit specification file only when writing commits."

Regardless of whether its mechanism is "read on load" or "read on commit," since the commits it produced did not comply with the specifications, both statements were hallucinations at the time. In the end, I had to obediently write the specifications explicitly into CLAUDE.md for it to finally listen.

Regarding the placement of specification files, this sparked another thought. I originally preferred to manage specifications in a "modular" way—that is, placing rule files in specific directories of the project and referencing them via links in CLAUDE.md to keep the configuration file concise, avoid overlap with README.md, and prevent each project from having its own specifications, which leads to inconsistencies.

However, after discussing with Gemini, I learned that such AI editors (like GitHub Copilot) usually only read specific configuration files by default (such as CLAUDE.md or .github/copilot-instructions.md). The "links" inside are just plain text paths to the AI and do not automatically read the content of those files into the context.

Therefore, the strategy must be adjusted. Although it is still necessary to establish a "central specification library" as the single source of truth, the application method has shifted from "referencing files" to "direct insertion": when opening a new project, I select appropriate modules (such as Git specifications, Vue specifications) from the central library and "copy-paste" the content directly into the CLAUDE.md file itself. Although this sacrifices conciseness, it ensures that the AI reads the specifications 100% while maintaining consistency across projects.

Best Practices for CLAUDE.md Configuration

According to the Determine memory type documentation, it is recommended to manage context in a layered manner:

• Global Settings: ~/.claude/CLAUDE.md. All sessions on the computer will read this setting.
• Project Settings: CLAUDE.md or .claude/CLAUDE.md (recommended) in the project root directory. This is the primary setting for the project; it is recommended to store it in the .claude folder to keep the root directory clean.
• Modular Rules: .claude/rules/*.md. The "modular" management mentioned earlier, splitting different specifications (e.g., git.md, vue.md) so Claude can read them as needed.
• Local Override: ./CLAUDE.local.md. Project-specific local rules; be sure to include it in .gitignore to avoid accidental commits.

Additionally, according to Claude Code: Best practices for agentic coding, we can define rules specific to certain subdirectories (e.g., backend/CLAUDE.md). Claude Code has an intelligent reading mechanism; when the Agent involves files in that directory, it will automatically read and apply these local contexts, achieving more precise specification control.

3. Hallucinations and Incorrect Information

In addition to the file reading mechanism mentioned above, it also hallucinates when providing suggestions. For example, when I asked where to put the specification file, it suggested putting it in the .github folder. But as everyone knows, .github is usually for GitHub Actions or Issue Templates and is not a standard place for documentation in the industry. This shows that developers still need to have the ability to judge when relying on AI suggestions.

4. Clumsiness and Conflicts in Git Operations

When performing Git operations, Claude Code sometimes appears "too clever for its own good":

• Taking the long way and being counterproductive: For tasks that could be easily solved with git rebase -i, it might take a long way around using other methods. When the result is not as expected, it automatically reverts and tries other methods. While the spirit is commendable, this mechanism doesn't always succeed and sometimes makes the Git graph even messier.
• Pitfalls of the snapshot mechanism: This is a common problem with all AI editors. It takes snapshots of files. If you manually intervene after it fails (e.g., manually resolving Git conflicts), it might ignore your changes and overwrite them with its old snapshots.

WARNING

If you want it to perform Git operations, it is safer to provide the Commit Hash directly rather than vaguely describing "modify that commit."

5. Performance Lag

When operating in the Desktop version, the interface has noticeable lag. Sometimes, because there was no response, I accidentally pressed Enter a few times, and it ended up sending multiple messages. Since it outputs a large amount of text every time a message is sent, it is easy to miss this. This not only causes operational confusion but may also lead to the quota being consumed repeatedly.

Conclusion

Although the experience was forced to end due to quota issues, and there is still much room for improvement in Git operations and session management, this experience truly showed me the turning point in development models.

AI tools are developing extremely fast. Early on, Vibe Coding was just a vague concept, but before you know it, it is gradually maturing. Of course, I don't think all work is suitable for Claude Code. Although I still believe Claude is the most suitable model for coding at this stage, every tool has its best use case, and the future development model should be "Multi-Model" collaboration.

For example, if the scenario is applied to Claude Code, the division of labor might look like this:

• Commit Message: Leave it to other free or cheaper AIs; don't waste Claude's quota.
• Complex Git Operations (Rebase): To avoid breaking the graph, I feel more comfortable doing these dangerous operations manually.
• Claude Code: Discussions or development tasks that require deep understanding of the project.
• Gemini / Other Models: If it's just asking general technical questions or not involving a large amount of project context, I would ask Gemini instead of Claude. If you use a Pro subscription, Claude Chat and Claude Code share the same quota.

However, I still need to spend time exploring how to find the best AI tool combination for myself based on the strengths and costs (Q.Q) of each model.

---

Change Log

• 2026-01-06 Initial document creation.
• 2026-01-07 Added official CLAUDE.md configuration best practices and context inheritance mechanism explanation.